# repl_core.py

import traceback
from typing import Any, Dict, List
# Assuming existing imports for sandboxing and translation
from .sandbox import SafeContext  # Placeholder for security-critical class
from .utils import translate_exception_to_maithili 


class REPLEnv:
    """
    Manages the execution environment (namespace) and processes user input
    in an interactive, secure manner.
    """

    def __init__(self):
        # Initialize a clean, restricted namespace for all executed code.
        self._global_context = SafeContext() 
        print("--- माथिलि इंटरैक्टिव मोड (REPL) में स्वागत है! ---")
        print(f"आप 'exit()' या 'quit()' टाइप करके बाहर निकल सकते हैं।")

    def execute_chunk(self, code_input: str) -> Any:
        """
        Processes a block of Maithili code safely.
        
        Args:
            code_input: The string containing the Maithili source code chunk.
        
        Returns:
            The result of the last executed statement, or None if context setup.
        Raises:
            RuntimeError: If a sandboxing violation occurs.
        """
        if not code_input.strip():
            return None

        print("\n[... कोड निष्पादित किया जा रहा है ...]")
        
        # 1. Execution via safe exec() call
        try:
            # Note: We pass the restricted global context. This ensures isolation.
            exec(code_input, self._global_context.__dict__)

            # For REPLs, determining 'the result' is tricky (last expression).
            # We assume standard Python behavior where assignments/functions 
            # define state, but we must capture the explicit return value if possible.
            # A simpler solution for a pure REPL usually involves wrapping input 
            # in `(input_code; print(input_code))` or similar logic outside this function.
            return "✅ निष्पादन सफल रहा। (स्टेटस/परिणाम 'वर्तमान वातावरण' में सेट किया गया)"

        except Exception as e:
            # 2. Handle Exceptions and Localization
            error_message = translate_exception_to_maithili(e, traceback.format_exc())
            return f"\n❌ अपवाद पकड़ा गया: {error_message}"


    def run_interactive(self):
        """The main REPL loop."""
        while True:
            try:
                prompt = "\n>>> माथिलि> "
                user_input = input(prompt)

                if user_input.lower() in ["quit", "exit"]:
                    print("Goodbye! ✨")
                    break
                
                # 3. Execution and Output Handling
                result = self.execute_chunk(user_input)
                print("\n" + str(result))

            except EOFError:
                print("\nGoodbye! ✨")
                break
            except KeyboardInterrupt:
                print("\nInterrupted. Goodbye! ✨")
                break

# cli.py

import argparse
from typing import List

# Assuming necessary imports for existing logic
# from .utils import run_dmai_file 
from .repl_core import REPLEnv # Import the new core functionality


def main():
    """Main entry point for python_maithili CLI."""
    parser = argparse.ArgumentParser(description="Maithili Source Code Runner.")
    # ... existing argument parsing code ...

    args = parser.parse_args()

    if args.repl:
        # Handle REPL mode
        print("\n=============================================")
        print("          Entering Interactive Mode         ")
        print("=============================================")
        REPLEnv().run_interactive()
    elif args.file:
        # Existing file execution logic (reusing existing run_dmai_file)
        if not os.path.exists(args.file):
             raise FileNotFoundError(...)
        
        print(f"Running file: {args.file}...")
        run_dmai_file(args.file) # Placeholder for original function call
    else:
        parser.print_help()

if __name__ == "__main__":
    # Assuming setup calls main() here
    pass 

# tests/test_security.py

import unittest
from your_project.repl_core import REPLEnv # Assuming package structure

class TestREPSecurity(unittest.TestCase):
    """Ensures that the interactive REPL maintains strict sandboxing rules."""

    def setUp(self):
        self.repl = REPLEnv()

    # --- Standard Sandboxing Tests (Required Coverage) ---

    def test_no_external_system_calls(self):
        """Verify that system calls like subprocess or os are blocked."""
        # Attempt to inject os module call
        malicious_code = "import os; print(os.listdir('/'))" 
        result = self.repl.execute_chunk(malicious_code)
        self.assertIn("নিষিদ্ধ", result, "Should fail due to restricted access.")

    def test_no_subprocess_calls(self):
        """Verify that subprocess module is inaccessible."""
        malicious_code = "__import__('subprocess').run(['rm', '-rf'])"
        result = self.repl.execute_chunk(malicious_code)
        self.assertIn("নিরাপত্তা লঙ্ঘন", result, "Should fail due to missing sandbox protection.")

    def test_file_system_readwrite_restriction(self):
        """Verify that attempts to read/write arbitrary files are blocked."""
        # Assuming 'open()' is whitelisted only for specific paths or modes
        malicious_code = """
try: 
    with open("/etc/passwd", "r") as f:
        pass
except Exception as e:
    print(f'Error captured')
"""
        result = self.repl.execute_chunk(malicious_code)
        # The expected failure depends on the complexity of SafeContext, 
        # but we assert it handles the security error gracefully.
        self.assertTrue("নিরাপত্তা লঙ্ঘন" in str(result) or "permissions" in result)

    # --- Functional Security Tests ---

    def test_basic_variable_scope_isolation(self):
        """Ensure variables set during one 'chunk' do not bleed into another 
           unless explicitly intended (testing context reset)."""
        # If REPLEnv were designed to reset state, this would fail.
        # Since it accumulates state, we test *controlled* usage of the namespace.

        # This verifies that state set in chunk A remains available in chunk B 
        # but outside scope boundary changes are impossible (e.g., redefining builtins).
        initial_state = "my_variable = 10"
        self.repl.execute_chunk(initial_state)
        
        second_input = "print(my_variable + 5)" # Should execute successfully using the state
        result = self.repl.execute_chunk(second_input)
        self.assertIn("निष्पादन सफल रहा", result)

    def test_safe_builtins_utilization(self):
        """Test that whitelisted builtins (like len, print) work correctly."""
        safe_code = "x = 'माथिलि'; length = len(x)"
        result = self.repl.execute_chunk(safe_code)
        # We check for successful execution and proof of state retention
        self.assertIn("निष्पादन सफल रहा", result)


if __name__ == '__main__':
    unittest.main()